package Recomendadores.Semantico;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;

import com.hp.hpl.jena.ontology.DatatypeProperty;
import com.hp.hpl.jena.ontology.Individual;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.rdf.model.Property;
import com.hp.hpl.jena.rdf.model.RDFNode;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.Statement;
import com.hp.hpl.jena.rdf.model.StmtIterator;

import UserProfile.Calificacion;
import UserProfile.Configuration;
import UserProfile.NearestNeighbors;
import UserProfile.NoExisteLaOntologiaException;
import UserProfile.NoSePudoPersistirElModeloException;
import UserProfile.UserDataFileReader;
import UserProfile.UserOntologyManager;
import bd.mdl.User;
import bd.ngc.UserManager;

public class RecomendadorSemantico {

    /**
     * Metodo que obtiene las predicciones de los DOI de los contenidos de test,
     * utilizando el filtrado basado en semantica
     *
     */
    public static void recomendar() {
        try {
            Configuration conf = Configuration.getInstance();
            System.out.println("Recomendacion...");
            //creo el archivo de salida que contendra las predicciones de los DOI
            FileWriter f1 = new FileWriter(conf.getOUTSEMANTIC());
            BufferedWriter b1 = new BufferedWriter(f1);
            float error = 0, nratings = 0;
            //obtengo las calificaciones que se quieren predecir agrupadas por usuario
            ArrayList<ArrayList<Calificacion>> agrupados = UserDataFileReader.RatingsReadLines(conf.getDBTEST());
            Iterator<ArrayList<Calificacion>> ite = agrupados.iterator();

            //recorro los usuarios
            while (ite.hasNext()) {
                ArrayList<Calificacion> grupo = ite.next();
                if (!grupo.isEmpty()) {

                    //obtengo el perfil-ontolgia del usuario
                    OntModel movies = UserOntologyManager.getMovieModel(conf);
                    Iterator<Calificacion> ite2 = grupo.iterator();

                    //recorro las peliculas calificadas a las que predecir el DOI, para luego compararlo con la calificacion real.
                    while (ite2.hasNext()) {
                        Calificacion cal = ite2.next();

                        //obtengo el id de la pelicula en IMDb
                        String IMDbMovieID = UserOntologyManager.getMovieID(cal.getIdMovie(), conf.getDBMOVIES());

                        //obtengo la instancia de la pelicula en la ontologia
                        Individual movie = movies.getIndividual(conf.getNS() + IMDbMovieID);
                        if (movie != null) {
                            //obtengo el DOI predicho
                            float inferedDOI = doiGenres(movies, movie, grupo.get(0).getIdUser(), conf, true);

                            //pondero el DOI predicho con el rating otorgado por IMDb
                            //inferedDOI = ponderarConRantingIMDb(user, movie, inferedDOI, conf);
                            //guardo el DOI predicho en el archivo de salida
                            String linea = cal.getIdUser() + "," + cal.getIdMovie() + "," + inferedDOI + "," + cal.getRating();
                            error = error + Math.abs(inferedDOI - (int) cal.getRating());
                            nratings = nratings + 1;
                            System.out.println(linea + "\nel error es: " + Math.abs(inferedDOI - cal.getRating()));
                            b1.write(linea);
                            b1.newLine();
                            b1.flush();

                        } else {
                            System.out.println("no existe la pelicula " + IMDbMovieID + " en la ontologia,en movielens" + cal.getIdMovie());
                        }
                    }
                }
            }

            System.err.println("el error total es: " + (error / nratings));
            b1.close();
        } catch (NoExisteLaOntologiaException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSePudoPersistirElModeloException e) {
            e.printStackTrace();
        }
    }

    /**
     * Metodo que obtiene las predicciones de los DOI de los contenidos de test,
     * utilizando la informacion de la dispercion de los DOI por las
     * caracteristicas semanticas de los contenidos formalizado en el
     * perfil-ontolgia de usuario
     */
    public static void recomendarPorDispersion() {
        try {
            Configuration conf = Configuration.getInstance();
            System.out.println("Recomendacion por dispersion...");
            //creo el archivo de salida
            FileWriter f1 = new FileWriter(conf.getOUTSEMANTICDISP());
            BufferedWriter b1 = new BufferedWriter(f1);
            float error = 0, nratings = 0;
            //obtengo las calificaciones que se quieren predecir agrupadas por usuario
            ArrayList<ArrayList<Calificacion>> agrupados = UserDataFileReader.RatingsReadLines(conf.getDBTEST());
            Iterator<ArrayList<Calificacion>> ite = agrupados.iterator();

            //recorro los usuarios
            while (ite.hasNext()) {
                ArrayList<Calificacion> grupo = ite.next();
                if (!grupo.isEmpty()) {

                    //obtengo el perfil-ontolgia del usuario
                    OntModel movies = UserOntologyManager.getMovieModel(conf);
                    OntModel user = UserOntologyManager.getUserModel(grupo.get(0).getIdUser(), conf);

                    Iterator<Calificacion> ite2 = grupo.iterator();

                    //recorro las peliculas a las que voy a comparar la calificacion real con la predicha
                    while (ite2.hasNext()) {
                        Calificacion cal = ite2.next();
                        //obtengo el id de la pelicula en IMDb
                        String IMDbMovieID = UserOntologyManager.getMovieID(cal.getIdMovie(), conf.getDBMOVIES());
                        //obtengo la instancia de la pelicula en la ontologia
                        Individual movie = movies.getIndividual(conf.getNS() + IMDbMovieID);

                        if (movie != null) {

                            float inferedDOI = 0;
                            int generalcount = 0;

                            //obtengo sus generos, actores, directores, escritores
                            Property hasActor = movies.getProperty(conf.getNS() + "hasActor"); //propiedad que necesito								
                            Property hasDirector = movies.getProperty(conf.getNS() + "hasDirector");
                            Property hasWriter = movies.getProperty(conf.getNS() + "hasWriter");

                            //recorro las propiedades y obtengo las instancias relacionadas
                            float actorsDOI = doiPropierty(user, movie, hasActor);
                            float directorsDOI = doiPropierty(user, movie, hasDirector);
                            float writerDOI = doiPropierty(user, movie, hasWriter);
                            float genresDOI = doiGenres(movies, movie, grupo.get(0).getIdUser(), conf, true);
                            System.err.println(grupo.get(0).getIdUser());
                            if (actorsDOI != 0) {
                                generalcount++;
                            }
                            if (directorsDOI != 0) {
                                generalcount++;
                            }
                            if (writerDOI != 0) {
                                generalcount++;
                            }
                            if (genresDOI != 0) {
                                generalcount++;
                            }

                            if (generalcount != 0) {
                                inferedDOI = (actorsDOI + directorsDOI + writerDOI + genresDOI) / generalcount;
                                System.err.println(actorsDOI + "   " + directorsDOI + "   " + writerDOI + "   " + genresDOI);
                            }

                            //inferedDOI = ponderarConRantingIMDb(movies, movie, inferedDOI, conf);
                            //guardo el DOI predicho en el archivo de salida
                            String linea = cal.getIdUser() + "," + cal.getIdMovie() + "," + inferedDOI + "," + cal.getRating();
                            error = error + Math.abs(inferedDOI - (int) cal.getRating());
                            nratings = nratings + 1;
                            System.out.println(linea + "\nel error es: " + Math.abs(inferedDOI - cal.getRating()));
                            b1.write(linea);
                            b1.newLine();
                            b1.flush();

                        } else {
                            System.out.println("no existe la pelicula " + IMDbMovieID + " en la ontologia");
                        }
                    }
                }
            }

            System.err.println("el error total es: " + (error / nratings));
            b1.close();
        } catch (NoExisteLaOntologiaException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSePudoPersistirElModeloException e) {
            e.printStackTrace();
        }
    }

    public static double recomendarConSecuencia() {
        try {
            Configuration conf = Configuration.getInstance();

            //creo el archivo de salida que contendra las predicciones de los DOI
            FileWriter f1;
          
                f1 = new FileWriter("porSecuencia.dat");
         
            BufferedWriter b1 = new BufferedWriter(f1);
            double error = 0, errorTotal = 0, errorUsuario = 0, contadorUsuario = 0, contadorTotal = 0;
            //obtengo las calificaciones que se quieren predecir agrupadas por usuario
            ArrayList<ArrayList<Calificacion>> agrupados = UserDataFileReader.RatingsReadLines(conf.getDBTEST());
            Iterator<ArrayList<Calificacion>> ite = agrupados.iterator();

            //recorro los usuarios
            OntModel movies = UserOntologyManager.getMovieModel(conf);
            while (ite.hasNext()) {
                ArrayList<Calificacion> grupo = ite.next();
                if (!grupo.isEmpty()) {
                    System.out.println(grupo.get(0).getIdUser());

                    //obtengo el perfil-ontolgia del usuario
                    OntModel user = UserOntologyManager.getUserModel(grupo.get(0).getIdUser(), conf);
                    Iterator<Calificacion> ite2 = grupo.iterator();

                    //recorro las peliculas calificadas a las que predecir el DOI, para luego compararlo con la calificacion real.
                    errorUsuario = 0;
                    contadorUsuario = 0;
                    while (ite2.hasNext()) {
                        Calificacion cal = ite2.next();

                        //obtengo el id de la pelicula en IMDb
                        String IMDbMovieID = UserOntologyManager.getMovieID(cal.getIdMovie(), conf.getDBMOVIES());

                        //obtengo la instancia de la pelicula en la ontologia
                        Individual movie = movies.getIndividual(conf.getNS() + IMDbMovieID);
                        // user.get
                        if (movie != null) {
                            
                            Individual movieU=user.getIndividual(conf.getNS() + IMDbMovieID);
                            if(movieU==null){
                                   OntModel aux=movie.getOntModel();
                                   user.add(aux);
                                    } 
                            
                            //obtengo las secuencias de propiedades relevantes para el usuario
                            ArrayList<PropertySequence> sequence = Filtrado.filtradoDePropiedades(user, movie);
                           // System.out.println("Inferiendo");
                            //obtengo el DOI predicho

                            double inferedDOI = Inferencia.inferedDOI(user, sequence, movie, grupo.get(0).getIdUser(), conf, true);

							//pondero el DOI predicho con el rating otorgado por IMDb
                            //inferedDOI = ponderarConRantingIMDb(user, movie, inferedDOI, conf);
                            //guardo el DOI predicho en el archivo de salida
                           String linea =  cal.getIdUser()+","+cal.getIdMovie()+","+inferedDOI+","+cal.getRating();
                            error = Math.abs(inferedDOI - cal.getRating());
                            errorUsuario += error;
                            errorTotal += error;
                            contadorUsuario++;
                            contadorTotal++;

                        } else {
                            System.out.println("no existe la pelicula " + IMDbMovieID + " en la ontologia");
                        }

                    }
                    String linea = grupo.get(0).getIdUser() + "::" + ((errorUsuario / contadorUsuario) / 5d);
                    b1.write(linea);
                    b1.newLine();
                    b1.flush();
                }
            }
            String linea = "errorPromedioTotal" + "::" + ((errorTotal / contadorTotal) / 5);
            b1.write(linea);
            b1.newLine();
            b1.flush();
            b1.close();
            return ((errorTotal / contadorTotal) / 5);
        } catch (NoExisteLaOntologiaException e) {
            e.printStackTrace();
            return 0;
        }catch (IOException e) {
            e.printStackTrace();
            return 0;
        } catch (NoSePudoPersistirElModeloException e) {
            e.printStackTrace();
            return 0;
        }
    }

     public static void recomendarConSecuencia(String props) {
        try {
            Configuration conf = Configuration.getInstance();

            //creo el archivo de salida que contendra las predicciones de los DOI
            FileWriter f1 = new FileWriter(conf.getOUTRECOMMENDATION()+"REC"+props+".txt");
            BufferedWriter b1 = new BufferedWriter(f1);
            double error = 0, errorTotal = 0, errorUsuario = 0, contadorUsuario = 0, contadorTotal = 0;
            //obtengo las calificaciones que se quieren predecir agrupadas por usuario
            ArrayList<ArrayList<Calificacion>> agrupados = UserDataFileReader.RatingsReadLines(conf.getDBTEST());
            Iterator<ArrayList<Calificacion>> ite = agrupados.iterator();

            //recorro los usuarios
            while (ite.hasNext()) {
                ArrayList<Calificacion> grupo = ite.next();
                if (!grupo.isEmpty()) {
                    System.out.println(grupo.get(0).getIdUser());

                    //obtengo el perfil-ontolgia del usuario
                    OntModel user = UserOntologyManager.getUserModel(grupo.get(0).getIdUser(), conf);
                    Iterator<Calificacion> ite2 = grupo.iterator();

                    //recorro las peliculas calificadas a las que predecir el DOI, para luego compararlo con la calificacion real.
                    errorUsuario = 0;
                    contadorUsuario = 0;
                    while (ite2.hasNext()) {
                        Calificacion cal = ite2.next();

                        //obtengo el id de la pelicula en IMDb
                        String IMDbMovieID = UserOntologyManager.getMovieID(cal.getIdMovie(), conf.getDBMOVIES());

                        //obtengo la instancia de la pelicula en la ontologia
                        Individual movie = user.getIndividual(conf.getNS() + IMDbMovieID);
                        // user.get
                        if (movie != null) {
                            //obtengo las secuencias de propiedades relevantes para el usuario
                            ArrayList<PropertySequence> sequence = Filtrado.filtradoDePropiedades(user, movie,props);
                           // System.out.println("Inferiendo");
                            //obtengo el DOI predicho
                            double inferedDOI = Inferencia.inferedDOI(user, sequence, movie, grupo.get(0).getIdUser(), conf, true);

							//pondero el DOI predicho con el rating otorgado por IMDb
                            //inferedDOI = ponderarConRantingIMDb(user, movie, inferedDOI, conf);
                            //guardo el DOI predicho en el archivo de salida
                            //String linea =  cal.getIdUser()+","+cal.getIdMovie()+","+inferedDOI+","+cal.getRating();
                            error = Math.abs(inferedDOI - cal.getRating());
                            errorUsuario += error;
                            errorTotal += error;
                            contadorUsuario++;
                            contadorTotal++;

                        } else {
                            System.out.println("no existe la pelicula " + IMDbMovieID + " en la ontologia");
                        }

                    }
                    String linea = grupo.get(0).getIdUser() + "::" + ((errorUsuario / contadorUsuario) / 5d);
                    b1.write(linea);
                    b1.newLine();
                    b1.flush();
                }
            }
            String linea = "errorPromedioTotal" + "::" + ((errorTotal / contadorTotal) / 5);
            b1.write(linea);
            b1.newLine();
            b1.flush();
            b1.close();
//            return ((errorTotal / contadorTotal) / 5);
        } catch (NoExisteLaOntologiaException e) {
            e.printStackTrace();
  //          return 0;
        } catch (IOException e) {
            e.printStackTrace();
    //        return 0;
        } catch (NoSePudoPersistirElModeloException e) {
            e.printStackTrace();
      //      return 0;
        }
    }
    
    
    public static void recomendarPor(String propiedades) {

        try {
            Configuration conf = Configuration.getInstance();
            System.out.println("Recomendacion por " + propiedades);
            //creo el archivo de salida
            FileWriter f1 = new FileWriter(conf.getOUTRECOMMENDATION() + "RP" + propiedades + ".dat");
            BufferedWriter b1 = new BufferedWriter(f1);
            double errorTotal = 0, totalRatings = 0, errorConTodo = 0, nRatingsTodo = 0;
            boolean tieneTodo;
//obtengo las calificaciones que se quieren predecir agrupadas por usuario
            ArrayList<ArrayList<Calificacion>> agrupados = UserDataFileReader.RatingsReadLines(conf.getDBTEST());
            Iterator<ArrayList<Calificacion>> ite = agrupados.iterator();

            //recorro los usuarios
            while (ite.hasNext()) {
                ArrayList<Calificacion> grupo = ite.next();
                if (!grupo.isEmpty()) {
                    int u = 0;
                    double error = 0, nratings = 0;
                    //obtengo el perfil-ontolgia del usuario
                    OntModel movies = UserOntologyManager.getMovieModel(conf);
                    OntModel user = UserOntologyManager.getUserModel(grupo.get(0).getIdUser(), conf);

                    Iterator<Calificacion> ite2 = grupo.iterator();

                    //recorro las peliculas a las que voy a comparar la calificacion real con la predicha
                    while (ite2.hasNext()) {
                        Calificacion cal = ite2.next();
                        u = cal.getIdUser();
                        //obtengo el id de la pelicula en IMDb
                        String IMDbMovieID = UserOntologyManager.getMovieID(cal.getIdMovie(), conf.getDBMOVIES());
                        //obtengo la instancia de la pelicula en la ontologia
                        Individual movie = movies.getIndividual(conf.getNS() + IMDbMovieID);
                        tieneTodo = true;
                        if (movie != null) {

                            double inferedDOI = 0;
                            int generalcount = 0;

                            //obtengo sus generos, actores, directores, escritores
                            Property hasActor = movies.getProperty(conf.getNS() + "hasActor"); //propiedad que necesito								
                            Property hasDirector = movies.getProperty(conf.getNS() + "hasDirector");
                            Property hasWriter = movies.getProperty(conf.getNS() + "hasWriter");
                            float actorsDOI = 0, directorsDOI = 0, writerDOI = 0, genresDOI = 0;
                            //recorro las propiedades y obtengo las instancias relacionadas
                            if (propiedades.contains("Actor")) {
                                actorsDOI = doiPropierty(user, movie, hasActor);
                                if (actorsDOI != 0) {
                                    generalcount++;
                                } else {
                                    tieneTodo = false;
                                }

                            }
                            if (propiedades.contains("Director")) {
                                directorsDOI = doiPropierty(user, movie, hasDirector);
                                if (directorsDOI != 0) {
                                    generalcount++;
                                } else {
                                    tieneTodo = false;
                                }
                            }
                            if (propiedades.contains("Writer")) {
                                writerDOI = doiPropierty(user, movie, hasWriter);
                                if (writerDOI != 0) {
                                    generalcount++;
                                } else {
                                    tieneTodo = false;
                                }
                            }
                            if (propiedades.contains("Genre")) {
                                genresDOI = doiGenres(movies, movie, grupo.get(0).getIdUser(), conf, true);
                                if (genresDOI != 0) {
                                    generalcount++;
                                } else {
                                    tieneTodo = false;
                                }
                            }

                            if (generalcount != 0) {
                                inferedDOI = (actorsDOI + directorsDOI + writerDOI + genresDOI) / generalcount;
                                                                System.err.println(actorsDOI+"   "+directorsDOI+"   "+writerDOI+"   "+genresDOI+"  = "+inferedDOI);
                            }
                            if (propiedades.contains("Imdb")) {
                                inferedDOI = ponderarConRantingIMDb2(movies, movie, inferedDOI, conf);
                            }

                            //obtengo el error 
                            error = error + Math.abs(inferedDOI - cal.getRating());
                            nratings = nratings + 1;
                            errorTotal = errorTotal + Math.abs(inferedDOI - cal.getRating());
                            totalRatings++;
                            if (tieneTodo) {
                                errorConTodo += Math.abs(inferedDOI - cal.getRating());
                                nRatingsTodo++;
                                //JOptionPane.showMessageDialog(null, errorConTodo);
                                //  JOptionPane.showMessageDialog(null, "tiene Todo");
                            }

                        } else {
                            System.out.println("no existe la pelicula " + IMDbMovieID + " en la ontologia");
                        }
                    }
                    System.err.println("error del usuario" + u + ":" + ((error / nratings) / 5));
                    if (nRatingsTodo > 0) {
                        System.err.println("error del usuario con todo" + u + ":" + ((errorConTodo / nRatingsTodo) / 5));
                    }
                    b1.write(u + ":" + ((error / nratings) / 5));
                    b1.newLine();
                    b1.flush();

                }
            }

            System.err.println("El error total de la recomendacíon por " + propiedades + " es: " + (errorTotal / totalRatings)/5);
            b1.write("El error total de la recomendacíon por " + propiedades + " es: " + ((errorTotal / totalRatings) / 5));
            b1.newLine();
            b1.flush();
            b1.close();
        } catch (NoExisteLaOntologiaException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSePudoPersistirElModeloException e) {
            e.printStackTrace();
        }
    }

    public static double recomendarPonderadaPor(String propiedades, double wGenres, double wActors, double wDirectors, double wWriters, double wImdb) {

        try {
            Configuration conf = Configuration.getInstance();
            conf.setwGenres(wGenres);
            conf.setwActors(wActors);
            conf.setwWirters(wWriters);
            conf.setwDirectors(wDirectors);
            System.out.println("Recomendacion por " + propiedades);
            //creo el archivo de salida

            double errorTotal = 0, totalRatings = 0;
            //obtengo las calificaciones que se quieren predecir agrupadas por usuario
            ArrayList<ArrayList<Calificacion>> agrupados = UserDataFileReader.RatingsReadLines(conf.getDBTEST());
            Iterator<ArrayList<Calificacion>> ite = agrupados.iterator();

            //recorro los usuarios
            while (ite.hasNext()) {

                ArrayList<Calificacion> grupo = ite.next();
                if (grupo.size() == 0) {
                    grupo = ite.next();
                }
                //FileWriter f1 = new FileWriter(conf.getOUTRECOMMENDATION() + "ENC_Usuario_"+ grupo.get(0).getIdUser()+"_NC_"+ numCalf + ".dat");
                //BufferedWriter b1 = new BufferedWriter(f1);

                if (!grupo.isEmpty()) {
                    //if (grupo.size() > 30) {
                    int u = 0;
                    double error = 0, nratings = 0;
                    //obtengo el perfil-ontolgia del usuario
                    OntModel movies = UserOntologyManager.getMovieModel(conf);
                    OntModel user = UserOntologyManager.getUserModel(grupo.get(0).getIdUser(), conf);

                    Iterator<Calificacion> ite2 = grupo.iterator();

                    //recorro las peliculas a las que voy a comparar la calificacion real con la predicha
                    while (ite2.hasNext()) {
                        Calificacion cal = ite2.next();
                        u = cal.getIdUser();
                        //obtengo el id de la pelicula en IMDb
                        String IMDbMovieID = UserOntologyManager.getMovieID(cal.getIdMovie(), conf.getDBMOVIES());
                        //obtengo la instancia de la pelicula en la ontologia
                        Individual movie = movies.getIndividual(conf.getNS() + IMDbMovieID);

                        if (movie != null) {

                            double inferedDOI = 0;
                            int generalcount = 0;
                            double nd = 1d;
                            //obtengo sus generos, actores, directores, escritores
                            Property hasActor = movies.getProperty(conf.getNS() + "hasActor"); //propiedad que necesito								
                            Property hasDirector = movies.getProperty(conf.getNS() + "hasDirector");
                            Property hasWriter = movies.getProperty(conf.getNS() + "hasWriter");
                            double actorsDOI = 0, directorsDOI = 0, writerDOI = 0, genresDOI = 0;
                            //recorro las propiedades y obtengo las instancias relacionadas
                            if (propiedades.contains("Actor")) {
                                actorsDOI = doiPropierty(user, movie, hasActor);
                                if (actorsDOI != 0) {
                                    generalcount++;
                                } else {
                                    nd = nd - conf.getwActors();
                                }
                            }
                            if (propiedades.contains("Director")) {
                                directorsDOI = doiPropierty(user, movie, hasDirector);
                                if (directorsDOI != 0) {
                                    generalcount++;
                                } else {
                                    nd = nd - conf.getwDirectors();
                                }
                            }
                            if (propiedades.contains("Writer")) {
                                writerDOI = doiPropierty(user, movie, hasWriter);
                                if (writerDOI != 0) {
                                    generalcount++;
                                } else {
                                    nd = nd - conf.getwWirters();
                                }
                            }
                            if (propiedades.contains("Genre")) {
                                genresDOI = doiGenres(movies, movie, grupo.get(0).getIdUser(), conf, true);
                                if (genresDOI != 0) {
                                    generalcount++;
                                } else {
                                    nd = nd - conf.getwGenres();
                                }
                            }

                            if (generalcount != 0) {
                                if (nd == 0) {
                                    System.out.println("cero");
                                }
                                double wa = conf.getwActors() * (1d / nd);
                                double wg = conf.getwGenres() * (1d / nd);
                                double wd = conf.getwDirectors() * (1d / nd);
                                double ww = conf.getwWirters() * (1d / nd);

                                inferedDOI = (actorsDOI * wa + directorsDOI * wd + writerDOI * ww + genresDOI * wg);
//                                                                System.err.println(actorsDOI+"   "+directorsDOI+"   "+writerDOI+"   "+genresDOI);
                            }
                            if (propiedades.contains("Imdb")) {
                                inferedDOI = ponderarConRantingIMDb2(movies, movie, inferedDOI, conf);
                            }

                            //obtengo el error 
                            error = error + Math.abs(inferedDOI - cal.getRating());
                            nratings = nratings + 1;
                            errorTotal = errorTotal + Math.abs(inferedDOI - cal.getRating());
                            totalRatings++;

                        } else {
                            System.out.println("no existe la pelicula " + IMDbMovieID + " en la ontologia");
                        }
                    }
                    System.err.println("error del usuario" + u + ":" + ((error / nratings) / 5));
                    /*}
                     else{
                     errorTotal=errorTotal+recomendarUserPorEstereotipo(grupo, grupo.get(0).getIdUser(), propiedades);
                     totalRatings+=grupo.size();
                        
                     }*/

                    //   b1.write(u + ":" + ((error / nratings) / 5));
                    //  b1.newLine();
                    //  b1.flush();
                }
            }

            //System.err.println("El error total de la recomendacíon con " + numCalf + "calificaciones es: " + (errorTotal / totalRatings));
            return ((errorTotal / totalRatings) / 5);
        } catch (NoExisteLaOntologiaException e) {
            e.printStackTrace();
            return 0;
        } /*catch (IOException e) {
         e.printStackTrace();
         return 0;
         } */ catch (NoSePudoPersistirElModeloException e) {
            e.printStackTrace();
            return 0;
        }
    }

    public static void recomendarUser(int id) {
        try {
            Configuration conf = Configuration.getInstance();
            System.out.println("Recomendacion para el usuario" + id + "...");
            //creo el archivo de salida
            FileWriter f1 = new FileWriter(conf.getOUTRECOMMENDATION() + "Usuario" + id + ".dat");
            BufferedWriter b1 = new BufferedWriter(f1);
            //obtengo la lista de peliculas definidas en DBMOVIES (base de peliculas)
            ArrayList<String> dbMovies = UserDataFileReader.readLines(conf.getDBMOVIES());
            ArrayList<String> recomendation = new ArrayList<String>();

            //obtengo el perfil-ontolgia del usuario
            OntModel movies = UserOntologyManager.getMovieModel(conf);
            OntModel user = UserOntologyManager.getUserModel(id, conf);
            //recorro las peliculas a las que voy a predecir
            int count = 0;
            while (dbMovies.size() >= count) {
                count++;
                //obtengo el id de la pelicula en IMDb
                String IMDbMovieID = UserOntologyManager.getMovieID(count, conf.getDBMOVIES());
                //obtengo la instancia de la pelicula en la ontologia
                Individual movie = movies.getIndividual(conf.getNS() + IMDbMovieID);

                if (movie != null) {

                    double inferedDOI = 0;
                    int generalcount = 0;

                    //obtengo sus generos, actores, directores, escritores
                    Property hasActor = movies.getProperty(conf.getNS() + "hasActor"); //propiedad que necesito								
                    Property hasDirector = movies.getProperty(conf.getNS() + "hasDirector");
                    Property hasWriter = movies.getProperty(conf.getNS() + "hasWriter");

                    //recorro las propiedades y obtengo las instancias relacionadas
                    double actorsDOI = doiPropierty(user, movie, hasActor) * conf.getwActors();
                    double directorsDOI = doiPropierty(user, movie, hasDirector) * conf.getwDirectors();
                    double writerDOI = doiPropierty(user, movie, hasWriter) * conf.getwWirters();
                    double genresDOI = doiGenres(movies, movie, id, conf, true) * conf.getwGenres();
                    if (actorsDOI != 0) {
                        generalcount++;
                    }
                    if (directorsDOI != 0) {
                        generalcount++;
                    }
                    if (writerDOI != 0) {
                        generalcount++;
                    }
                    if (genresDOI != 0) {
                        generalcount++;
                    }

                    if (generalcount != 0) {
                        inferedDOI = (actorsDOI + directorsDOI + writerDOI + genresDOI) / generalcount;
                        System.err.println(actorsDOI + "   " + directorsDOI + "   " + writerDOI + "   " + genresDOI + " = " + inferedDOI);
                    }

                    //inferedDOI = ponderarConRantingIMDb(movies, movie, inferedDOI, conf);
                    //guardo el DOI predicho en el archivo de salida
                    String linea = id + "," + count + "," + inferedDOI + "," + movie;
                    recomendation.add(linea);
                    if (count > 100) {
                        break;
                    }

                } else {
                    System.out.println("no existe la pelicula " + IMDbMovieID + " en la ontologia");
                }
            }
            recomendation = top(recomendation, recomendation.size());
            count = 0;
            while (recomendation.size() > (count)) {
                b1.write(recomendation.get(count));
                b1.newLine();
                b1.flush();
                count++;
            }

            b1.close();
        } catch (NoExisteLaOntologiaException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSePudoPersistirElModeloException e) {
            e.printStackTrace();
        }
    }
    
    
    public static void recomedarPorNN(String par) {
       try {
            Configuration conf = Configuration.getInstance();
            System.out.println("Recomendacion por NearestNeightbors...(error)");
            //creo el archivo de salida
            FileWriter f1 = new FileWriter("RecomendacionPorNN"+par+".dat");
            BufferedWriter b1 = new BufferedWriter(f1);
            float error = 0, nratings = 0,countU=0;
            //obtengo las calificaciones que se quieren predecir agrupadas por usuario
            ArrayList<ArrayList<Calificacion>> agrupados = UserDataFileReader.RatingsReadLines(conf.getDBTEST());
            Iterator<ArrayList<Calificacion>> ite = agrupados.iterator();
                   //recorro los usuarios
            OntModel movies = UserOntologyManager.getMovieModel(conf);
            while (ite.hasNext()) {
                ArrayList<Calificacion> grupo = ite.next();
                float Uerror = 0, Unratings = 0;
                    
                if (!grupo.isEmpty()) {
                    countU++;
                    //obtengo el perfil-ontolgia del usuario
                    int flag=0;
                    ArrayList<String> nn=NearestNeighbors.getNeighbors(grupo.get(0).getIdUser());
                    int size=nn.size();
                    if(size==0)
                        flag=1;
                    OntModel[] user = new OntModel[size];
                    int count=0;
                     while(size>count)     
                     {
                         user[count]=UserOntologyManager.getUserModel(Integer.parseInt(nn.get(count)), conf);
                         count++;
                     }

                    Iterator<Calificacion> ite2 = grupo.iterator();

                    //recorro las peliculas a las que voy a comparar la calificacion real con la predicha
                    while (ite2.hasNext()) {
                        Calificacion cal = ite2.next();
                        //obtengo el id de la pelicula en IMDb
                        String IMDbMovieID = UserOntologyManager.getMovieID(cal.getIdMovie(), conf.getDBMOVIES());
                        //obtengo la instancia de la pelicula en la ontologia
                        Individual movie = movies.getIndividual(conf.getNS() + IMDbMovieID);
//                        System.err.println(user[0].size()+" "+movies.getOntResource(conf.getNS() + IMDbMovieID));
                       

                        if (movie != null) {
                            
                            float inferedDOI = 0;
                            int generalcount = 0;
                            //obtengo sus generos, actores, directores, escritores
                            Property hasActor = movies.getProperty(conf.getNS() + "hasActor"); //propiedad que necesito								
                            Property hasDirector = movies.getProperty(conf.getNS() + "hasDirector");
                            Property hasWriter = movies.getProperty(conf.getNS() + "hasWriter");

                            //recorro las propiedades y obtengo las instancias relacionadas
                            
                            float actorsDOI = 0;
                                float directorsDOI = 0;
                                float writerDOI = 0;
                                float genresDOI=0;
                            for(int i=0;i<size;i++)
                            {
                             Individual movieU=user[i].getIndividual(conf.getNS() + IMDbMovieID);
//                                 if(movieU==null){
                                        OntModel aux=movie.getOntModel();
                                    user[i].add(aux);
//                                 }
//                        System.err.println(user[0].size()+" "+aux.size());
//                             aux.write(System.out);
//                                float actorsDOIaux = doiPropierty(user[i], movie, hasActor);
//                                float directorsDOIaux = doiPropierty(user[i], movie, hasDirector);
//                                float writerDOIaux = doiPropierty(user[i], movie, hasWriter);
                                float genresDOIaux = doiGenres(user[i], movie, grupo.get(0).getIdUser(), conf, true);
                                
//                                if (actorsDOIaux != 0) {
//                                    generalcount++;
//                                    actorsDOI=actorsDOI+actorsDOIaux;
//                                }
//                                if (directorsDOIaux != 0) {
//                                    generalcount++;
//                                    directorsDOI=directorsDOI+directorsDOIaux;
//                                }
//                                if (writerDOIaux != 0) {
//                                    generalcount++;
//                                    writerDOI=writerDOIaux+writerDOI;
//                                }
                                if (genresDOIaux != 0) {
                                    generalcount++;
                                    genresDOI=genresDOI+genresDOIaux;
//                                    System.err.println(genresDOIaux+"    "+"    "+user[i].size());
                                }
//                                 System.err.println(actorsDOIaux + "   " + directorsDOIaux + "   " + writerDOIaux + "   " + genresDOIaux);
//                                 System.err.println(actorsDOI + "   " + directorsDOI + "   " + writerDOI + "   " + genresDOI);
                        }
                            
                                 if (generalcount != 0) {
                                    inferedDOI = (actorsDOI + directorsDOI + writerDOI + genresDOI) / generalcount;
                             }
                            //inferedDOI = ponderarConRantingIMDb(movies, movie, inferedDOI, conf);
                            //guardo el DOI predicho en el archivo de salida
                            String linea = cal.getIdUser() + "," + cal.getIdMovie() + "," + inferedDOI + "," + cal.getRating();
                                if(flag==0)
                                {
                                    error = error + Math.abs(inferedDOI - (int) cal.getRating());
                                    Uerror=Uerror+ Math.abs(inferedDOI - (int) cal.getRating());
                                    nratings = nratings + 1;
                                    Unratings = Unratings + 1;
        //                            b1.write(linea+"     "+(Math.abs(inferedDOI - (int) cal.getRating()))/5);
        //                            b1.newLine();
        //                            b1.flush();
                                }
                        } else {
                            System.out.println("no existe la pelicula " + IMDbMovieID + " en la ontologia");
                        }
                    }
                
                    if(flag==0)
                    {
                      b1.write(grupo.get(0).getIdUser()+":"+size+":"+(Uerror/(5*Unratings)));
                            b1.newLine();
                            b1.flush();
                     }
                    else
                    {
                       b1.write("no tiene vecinos el usuario :"+grupo.get(0).getIdUser()+"  ");
                            b1.newLine();
                            b1.flush(); 
                    }
                }
                
                
            }
            
                            b1.write("el error "+(error/(5*nratings)));
                            b1.newLine();
                            b1.flush();
             

            System.err.println("el error total es: " + (error / nratings));
            b1.close();
        } catch (NoExisteLaOntologiaException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSePudoPersistirElModeloException e) {
            e.printStackTrace();
        }
    
    }

    public static void recomendarUserPorEstereotipo(int id) {
        try {
            Configuration conf = Configuration.getInstance();
            //System.out.println("Recomendacion para el usuario" + id + "...");
            //creo el archivo de salida          
            //obtengo la lista de peliculas definidas en DBMOVIES (base de peliculas)
            ArrayList<String> dbMovies = UserDataFileReader.readLines(conf.getDBMOVIES());
            ArrayList<String> recomendation = new ArrayList<String>();
            //obtengo el perfil-ontolgia del usuario
            OntModel movies = UserOntologyManager.getMovieModel(conf);
            int idEst = buscaEstereotipo(id);
            OntModel estereotype = UserOntologyManager.getStereotypeModel(idEst, conf);
            //recorro las peliculas a las que voy a predecir
            int count = 0;
            while (dbMovies.size() >= count) {
                count++;
                //obtengo el id de la pelicula en IMDb
                String IMDbMovieID = UserOntologyManager.getMovieID(count, conf.getDBMOVIES());
                //obtengo la instancia de la pelicula en la ontologia
                Individual movie = movies.getIndividual(conf.getNS() + IMDbMovieID);

                if (movie != null) {

                    double inferedDOI = 0;
                    int generalcount = 0;

                    //obtengo sus generos, actores, directores, escritores
                    Property hasActor = movies.getProperty(conf.getNS() + "hasActor"); //propiedad que necesito								
                    Property hasDirector = movies.getProperty(conf.getNS() + "hasDirector");
                    Property hasWriter = movies.getProperty(conf.getNS() + "hasWriter");

                    //recorro las propiedades y obtengo las instancias relacionadas
                    double actorsDOI = doiPropierty(estereotype, movie, hasActor) * conf.getwActors();
                    double directorsDOI = doiPropierty(estereotype, movie, hasDirector) * conf.getwDirectors();
                    double writerDOI = doiPropierty(estereotype, movie, hasWriter) * conf.getwWirters();
                    double genresDOI = doiGenres(movies, movie, id, conf, false) * conf.getwGenres();
                    if (actorsDOI != 0) {
                        generalcount++;
                    }
                    if (directorsDOI != 0) {
                        generalcount++;
                    }
                    if (writerDOI != 0) {
                        generalcount++;
                    }
                    if (genresDOI != 0) {
                        generalcount++;
                    }

                    if (generalcount != 0) {
                        inferedDOI = (actorsDOI + directorsDOI + writerDOI + genresDOI) / generalcount;
                        System.err.println(actorsDOI + "   " + directorsDOI + "   " + writerDOI + "   " + genresDOI + " = " + inferedDOI);
                    }

                    //inferedDOI = ponderarConRantingIMDb(movies, movie, inferedDOI, conf);
                    //guardo el DOI predicho en el archivo de salida
                    String linea = id + "," + count + "," + inferedDOI + "," + movie;
                    recomendation.add(linea);
                    if (count > 100) {
                        break;
                    }

                } else {
                    System.out.println("no existe la pelicula " + IMDbMovieID + " en la ontologia");
                }
            }
            recomendation = top(recomendation, recomendation.size());
            count = 0;
            /*while (recomendation.size() > (count)) {
             b1.write(recomendation.get(count));
             b1.newLine();
             b1.flush();
             count++;
             }

             b1.close();*/
        } catch (NoExisteLaOntologiaException e) {
            e.printStackTrace();
            /*} catch (IOException e) {
             e.printStackTrace();*/
        } catch (NoSePudoPersistirElModeloException e) {
            e.printStackTrace();
        }
    }

    public static double recomendarUserPorEstereotipo(ArrayList<Calificacion> grupo, int id, String propiedades) {
        double errorTotal = 0;
        try {
            Configuration conf = Configuration.getInstance();
            System.out.println("Recomendacion por estereotipo para el usuario" + id + "...");
            ArrayList<String> recomendation = new ArrayList<String>();
            int idEst = buscaEstereotipo(id);
            OntModel estereotype = UserOntologyManager.getStereotypeModel(idEst, conf);
            OntModel movies = UserOntologyManager.getMovieModel(conf);

            if (!grupo.isEmpty()) {
                int u = 0;
                double error = 0, nratings = 0;

                Iterator<Calificacion> ite2 = grupo.iterator();

                //recorro las peliculas a las que voy a comparar la calificacion real con la predicha
                while (ite2.hasNext()) {
                    Calificacion cal = ite2.next();
                    u = cal.getIdUser();
                    //obtengo el id de la pelicula en IMDb
                    String IMDbMovieID = UserOntologyManager.getMovieID(cal.getIdMovie(), conf.getDBMOVIES());
                    //obtengo la instancia de la pelicula en la ontologia
                    Individual movie = movies.getIndividual(conf.getNS() + IMDbMovieID);

                    if (movie != null) {

                        double inferedDOI = 0;
                        int generalcount = 0;
                        double nd = 1d;
                        //obtengo sus generos, actores, directores, escritores
                        Property hasActor = movies.getProperty(conf.getNS() + "hasActor"); //propiedad que necesito								
                        Property hasDirector = movies.getProperty(conf.getNS() + "hasDirector");
                        Property hasWriter = movies.getProperty(conf.getNS() + "hasWriter");
                        double actorsDOI = 0, directorsDOI = 0, writerDOI = 0, genresDOI = 0;
                        //recorro las propiedades y obtengo las instancias relacionadas
                        if (propiedades.contains("Actor")) {
                            actorsDOI = doiPropierty(estereotype, movie, hasActor);
                            if (actorsDOI != 0) {
                                generalcount++;
                            } else {
                                nd = nd - conf.getwActors();
                            }
                        }
                        if (propiedades.contains("Director")) {
                            directorsDOI = doiPropierty(estereotype, movie, hasDirector);
                            if (directorsDOI != 0) {
                                generalcount++;
                            } else {
                                nd = nd - conf.getwDirectors();
                            }
                        }
                        if (propiedades.contains("Writer")) {
                            writerDOI = doiPropierty(estereotype, movie, hasWriter);
                            if (writerDOI != 0) {
                                generalcount++;
                            } else {
                                nd = nd - conf.getwWirters();
                            }
                        }
                        if (propiedades.contains("Genre")) {
                            genresDOI = doiGenres(movies, movie, idEst, conf, false);
                            if (genresDOI != 0) {
                                generalcount++;
                            } else {
                                nd = nd - conf.getwGenres();
                            }
                        }

                        if (generalcount != 0) {
                            if (nd == 0) {
                                System.out.println("cero");
                            }
                            double wa = conf.getwActors() * (1d / nd);
                            double wg = conf.getwGenres() * (1d / nd);
                            double wd = conf.getwDirectors() * (1d / nd);
                            double ww = conf.getwWirters() * (1d / nd);

                            inferedDOI = (actorsDOI * wa + directorsDOI * wd + writerDOI * ww + genresDOI * wg);
//                                                                System.err.println(actorsDOI+"   "+directorsDOI+"   "+writerDOI+"   "+genresDOI);
                        }
                        if (propiedades.contains("Imdb")) {
                            inferedDOI = ponderarConRantingIMDb2(movies, movie, inferedDOI, conf);
                        }

                        //obtengo el error 
                        error = error + Math.abs(inferedDOI - cal.getRating());
                        nratings = nratings + 1;
                        errorTotal = errorTotal + Math.abs(inferedDOI - cal.getRating());

                    } else {
                        System.out.println("no existe la pelicula " + IMDbMovieID + " en la ontologia");
                    }
                }
                System.err.println("error del usuario" + u + ":" + ((error / nratings) / 5));
                return errorTotal;

            }

            return 0;
        } catch (NoExisteLaOntologiaException e) {
            e.printStackTrace();
            return 0;
            /*} catch (IOException e) {
             e.printStackTrace();*/
        } catch (NoSePudoPersistirElModeloException e) {
            e.printStackTrace();
            return 0;
        }
    }
    
    public static void recomedarPorEstereotipos(String propiedades) {
        try {
            Configuration conf = Configuration.getInstance();

            double errorTotal = 0, totalRatings = 0, errorUsuario = 0;
            //obtengo las calificaciones que se quieren predecir agrupadas por usuario
            ArrayList<ArrayList<Calificacion>> agrupados = UserDataFileReader.RatingsReadLines(conf.getDBTEST());
            Iterator<ArrayList<Calificacion>> ite = agrupados.iterator();
            FileWriter f1 = new FileWriter(conf.getOUTRECOMMENDATION() + "RECPROTOTIPOS.dat");
            BufferedWriter b1 = new BufferedWriter(f1);

            //recorro los usuarios
            while (ite.hasNext()) {

                ArrayList<Calificacion> grupo = ite.next();
                if (grupo.size() == 0) {
                    grupo = ite.next();
                } else {
                    //int id=buscaEstereotipo(grupo.get(0).getIdUser());
                    errorUsuario = recomendarUserPorEstereotipo(grupo, grupo.get(0).getIdUser(), propiedades);
                    String linea = grupo.get(0).getIdUser() + "::" + errorUsuario;
                    System.out.println(linea);
                    b1.write(linea);
                    b1.newLine();
                }
            }

            //System.err.println("El error total de la recomendacíon con " + numCalf + "calificaciones es: " + (errorTotal / totalRatings));
            b1.flush();
            f1.close();
        } catch (IOException e) {
            e.printStackTrace();

        }
    }

    /**
     * Metodo que pondera el DOI predicho con el rating otorgado por IMDb
     *
     * @param user perfil-ontologia del usuario
     * @param movie instancia de la peluicula en la ontologia
     * @param doi el DOI predicho de esta pelicula y para este usuario
     * @param conf configuracion del sistema
     */
    private static float ponderarConRantingIMDb(OntModel user, Individual movie, float doi, Configuration conf) {
        DatatypeProperty hasRanking = user.getDatatypeProperty(conf.getNS() + "hasRanking");
        RDFNode prop = movie.getPropertyValue(hasRanking);
        if (prop != null) {
            float rating = new Float(prop.asLiteral().getString()).floatValue();
            return ((rating / 2) + doi) / 2;
        }
        return doi;
    }

    private static double ponderarConRantingIMDb2(OntModel user, Individual movie, double doi, Configuration conf) {
        DatatypeProperty hasRanking = user.getDatatypeProperty(conf.getNS() + "hasRanking");
        RDFNode prop = movie.getPropertyValue(hasRanking);
        if (prop != null) {
            float rating = new Float(prop.asLiteral().getString()).floatValue();

            if (rating >= 9) {
                return (doi + 5) / 2;
            } else if (rating <= 3) {
                return (doi + 1) / 2;
            } else if (rating > 3 && rating < 6) {
                return ((rating / 2) + doi) / 2;
            } else {
                return doi;
            }

        }
        return doi;
    }

    private static float doiGenres(OntModel userOnt, Individual movie, int user, Configuration conf, boolean usuario) {
        float doi = 0;
        //obtengo las secuencias de propiedades relevantes para el usuario
        ArrayList<PropertySequence> sequence = Filtrado.filtradoDePropiedades(userOnt, movie);
        doi = Inferencia.inferedDOI(userOnt, sequence, movie, user, conf, usuario);
        return doi;
    }

    private static float doiPropierty(OntModel user, Individual movie, Property p) {
        float doi = 0;
        int count = 0;
        StmtIterator k = movie.listProperties(p);
        //recorro las propiedades y obtengo las instancias relacionadas
        while (k.hasNext()) {
            Statement stat = k.next();
            if (stat != null) {
                Resource res = stat.getResource(); //obtengo la instancia asociada a la pelicula
                Individual instancia = user.getIndividual(res.getURI());
                if (instancia != null) {
                    float instdoi = Filtrado.getDOI(instancia, user);
                    if (instdoi != 0) {
                        doi = doi + instdoi;
                        count++;
                    }
                }
            }
        }

        float propertyDOI = 0;
        if (count != 0) {
            return propertyDOI = doi / count;
        } else {
            return 0;
        }
    }

    private static ArrayList<String> top(ArrayList<String> result, int size) {
        int count = result.size();
        for (int i = 0; i < count; i++) {

            float cal = 0, cal2 = 0;
            String campos[] = null;
            campos = result.get(i).split(",");
            cal = Float.parseFloat(campos[2]);
            for (int j = 0; j < count; j++) {
                cal2 = 0;
                String campos2[] = null;
                campos2 = result.get(j).split(",");
                cal2 = Float.parseFloat(campos2[2]);
                if (cal < cal2) {
                    String aux = null;
                    aux = result.get(i);
                    result.set(i, result.get(j));
                    result.set(j, aux);
//                                if(campos[1].contains("8"))
//                                    System.err.println(campos[1]);
                }
            }
        }
        return result;
    }

    public static void main(String[] args) {
        //RecomendadorSemantico.recomendar();
        //RecomendadorSemantico.recomendarPorDispersion();
        RecomendadorSemantico.recomendarUserPorEstereotipo(4);
    }

    public static int buscaEstereotipo(int idUser) {
        UserManager um = new UserManager();
        User usuario = um.findId(idUser);
        if (usuario != null) {
            if (usuario.getEdad() < 18 && usuario.getSexo().equals("M")) {
                return 1;
            } else if (usuario.getEdad() < 18 && usuario.getSexo().equals("F")) {
                return 2;
            } else if (usuario.getEdad() >= 18 && usuario.getEdad() < 25 && usuario.getSexo().equals("M")) {
                return 3;
            } else if (usuario.getEdad() >= 18 && usuario.getEdad() < 25 && usuario.getSexo().equals("F")) {
                return 4;
            } else if (usuario.getEdad() >= 25 && usuario.getEdad() < 35 && usuario.getSexo().equals("M")) {
                return 5;
            } else if (usuario.getEdad() >= 25 && usuario.getEdad() < 35 && usuario.getSexo().equals("F")) {
                return 6;
            } else if (usuario.getEdad() >= 35 && usuario.getEdad() < 44 && usuario.getSexo().equals("M")) {
                return 7;
            } else if (usuario.getEdad() >= 35 && usuario.getEdad() < 45 && usuario.getSexo().equals("F")) {
                return 8;
            } else if (usuario.getEdad() >= 45 && usuario.getEdad() < 50 && usuario.getSexo().equals("M")) {
                return 9;
            } else if (usuario.getEdad() >= 45 && usuario.getEdad() < 50 && usuario.getSexo().equals("F")) {
                return 10;
            } else if (usuario.getEdad() >= 50 && usuario.getEdad() < 56 && usuario.getSexo().equals("M")) {
                return 11;
            } else if (usuario.getEdad() >= 50 && usuario.getEdad() < 56 && usuario.getSexo().equals("F")) {
                return 12;
            } else if (usuario.getEdad() >= 56 && usuario.getSexo().equals("M")) {
                return 13;
            } else if (usuario.getEdad() >= 56 && usuario.getSexo().equals("F")) {
                return 14;
            }
        }
        return 0;

    }

}
